public class Test {
//
//    public static void main1(String[] args) {
//        Dog d = new Dog();
//        d.name = "坦克";
//        d.bark();
//        Cat c = new Cat();
//        c.name = "咪咪";
//        c.mew();
//        c.eat();
//    }
//
//    public static void main2(String[] args) {
//        Derived d = new Derived();
//        System.out.println(d.a);
//        d.func1();
//    }

    public static void main(String[] args) {

    }
}
//子类继承了父类的属性和行为，但是子类也会有自己的行为
//实现了代码的复用

//父类成员的访问
//子类当中访问父类成员变量
//子类有，就从子类中拿，子类没有，就从父类中拿
//子类和父类成员变量同名的时候,优先访问子类自己的（就近原则）
//对象的内存里面会包含两个同名的变量，两个都会包含，但是使用的时候
//如果没有说明，就优先使用子类的（就近原则）
//super关键字 代表父类的引用？？？错误说法，当前关键字说明成员变量或者成员方法是来自父类的
//super的用法：调用成员变量
//成员方法
//方法名称不相同
//先从子类中找，子类找不到，去父类找，找不到报错
//方法名称相同
//先优先使用子类的方法，就近原则
//如果想要使用父类的方法，则需要关键字super
//super.data     在子类当中 访问父类的成员变量
//super.func()   在子类当中 访问父类的成员方法


//super关键字的作用，在子类方法中访问父类的成员方法
//方法重载需要在同一个类中吗？  不需要  子类和父类的方法名相同（在继承关系上也认为是同一个类，也认为是重载）
//参数列表不同可以构成重载
//重载在同一个类里的前提是有继承关系的两个类也可以认为是同一个类
//如果是继承关系上，也可以认为是重载

//super是获取子类从基类继承下来的部分
//super只是一个关键字,最大的作用就是在写代码或者读代码的时候体现出更好的可读性
//super只能在非静态方法中使用，
//super只能访问到父亲，不能访问爷爷类的，只能指代直接父类



//子类构造方法
//

//在调用子类构造方法帮助子类构造之前，一定要先调用父
// 类构造方法帮助父类成员初始化
//如果子类没有自己写构造方法，则编译器默认提供无参构
// 造，且在无参构造中调用父类的无参构造 即super()
//如果父类自己重写了构造方法，那么子类当中调用的无
// 参构造就会失效，不存在，所以需要用户自行调用父类的有参构造
//用户不定义，则自动调用无参构造
//用户定义了无参，则也不会报错，因为本来调用的就是无参
//用户定义了有参。则会报错，因为调用的无参此时不见了
// ，父类成员变量无人初始化，就会报错



class A {
    public int a;
    public int b;
    public int c;
    public static int d = 99;
    public static void func() {

    }
}

class B extends A {

    public static void func1() {
//        System.out.println(super.a);
//       static是修饰类的，但是super和this是调用对象的，有类不一定有对象，所以在静态方法里面不能使用super和this

    }

    public void fun2() {
        System.out.println(super.d);
    }

    public static void main(String[] args) {
        B b = new B();
        b.fun2();
    }
}



//super调用构造方法
//


class Animal {
    public String name;
    public int age;

    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("两参构造");
    }

    public Animal() {

    }

    public void eat() {
        System.out.println(name + " eat");
    }
}

//在继承关系上，当我们在构造子类的时候，一定要先帮
// 助父类进行构造（这句话的意思是，在给子类成员变
// 量初始化即调用子类构造方法之前，要先调用父类的
// 构造方法，帮助父类成员初始化）
//怎么帮助父类构造，在子类构造中调用父类构造方法

//super在子类调用父类构造一定要放在第一行，之后再为
// 子类其他成员变量赋值，否则会报错

//super()和this()在调用构造方法时不能同时出现

//当父类和子类都没有提供任何构造方法时，编译器默认提供
//但是一旦自定义，编译器就不再提供

//super调用构造方法，并没有构造父类对象，只是对我们继承来的属性进行初始化，并没有构造父类对象

class Dog extends Animal {
    public int size;

    public Dog(String name,int age,int size) {
        super(name,age);
        this.size = size;

    }
    public Dog() {
      //  super("七月",3);
        //显示的调用父类的构造方法，
        // 帮助父类的成员进行初始化
    }

    public void bark() {
        System.out.println("wangwang");
    }
}

//class Base {
//    public int a;
//    public int b;
//    public int c = 9;
//
//    public void func2() {
//        System.out.println("2222222");
//    }
//
//
//}
//
//class Derived extends Base{
//    public int c = 199;
//
//    public void func() {
//        System.out.println("func ");
//        System.out.println(a);
//        System.out.println(b);
//        System.out.println(c);//调用子类的c变量
//        System.out.println(super.c);//调用父类的c变量
//        //a和b来自父类，是从父类继承来的
//    }
//    public void func1() {
//
//    }
//    public void func2() {
//        System.out.println("11111111");
//    }
//}
//
//class Animal {
//    public String name;
//    public int age;
//
//    public void eat() {
//        System.out.println(name + "正在吃饭");
//    }
//}
////父类/基类/超类
//
//class Dog extends Animal {
//
//    public void bark() {
//        System.out.println("wangwang");
//    }
//}
//
//class Cat extends Animal {
//
//    public void mew() {
//        System.out.println("miaomiao");
//    }
//}

//子类/派生类


//父子，先有父，再有子，所以要先调用父类构造，再调用子类构造
//super只是一个关键字，表示父类成员变量或者父类方法调用
//super只能在子类构造方法内才能调用
